fix(db): compose optimistic updates from changes instead of whole-row snapshots - #1701

🎯 Changes

Small fix to how the optimistic overlay composes rows.

Today an optimistic insert/update stores mutation.modified — the whole row as it looked at mutate() time — into optimisticUpserts. Since modified is built from the visible row (Object.assign({}, visibleRow, payload) in mutations.ts), whichever transaction sorts last dictates every field, including ones it never touched.

The clearest symptom: rolling back one of several in-flight transactions doesn't actually remove its change.

It doesn't change when committed sync gets applied. Sync still stays queued while a transaction is persisting, exactly as today. That's the half of #1630 that turned out to be unsound without temp/server key mapping, and it's not needed for any of this.

So this is only the projection half — same base as before, just composed per-field instead of replaced wholesale.

Related to RFC #1625.

// three transactions in flight on the same row
t1.mutate(() => collection.update(1, (d) => { d.a = `a1` }))
t2.mutate(() => collection.update(1, (d) => { d.b = `b2` }))
t3.mutate(() => collection.update(1, (d) => { d.c = `c3` }))
t1.commit(); t2.commit(); t3.commit()

t2.rollback()
// expected: { a: 'a1', b: 'b0', c: 'c3' }
// actual:   { a: 'a1', b: 'b2', c: 'c3' }   <- b2 is back

t3's snapshot was taken when b was already b2, so once t2 is gone t3 puts it right back. I don't think there's a reading of that which is correct.

The fix: update mutations now compose mutation.changes over the value they were layered on, so a mutation only owns the fields it actually changed. Inserts keep using modified, since an insert's changes deliberately omit schema defaults (there's a comment in mutations.ts saying as much).

✅ Checklist

• I have tested this code locally with pnpm test.

🚀 Release Impact

• This change affects published code, and I have generated a changeset.
• This change is docs/CI/dev-only (no release).

Summary by CodeRabbit

• Bug Fixes
  • Fixed concurrent optimistic updates so each transaction changes only the fields it modified.
  • Prevented rollbacks from overwriting unrelated updates or leaving stale values visible.
  • Preserved optimistic insert defaults when subsequent updates are applied.
  • Prevented redundant change notifications when an optimistic overlay produces no effective change.